home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / toolfix.arc / BIGTRE.BOX next >
Encoding:
Text File  |  1987-03-03  |  12.8 KB  |  404 lines
  1.  
  2.           (*******************************************)
  3.           (*                                         *)
  4.           (*              BIGTREE.BOX                *)
  5.           (*    (for PC-DOS and MS-DOS systems)      *)
  6.           (*                                         *)
  7.           (*                  by                     *)
  8.           (*            Bruce A. Butters             *)
  9.           (*                                         *)
  10.           (*         updated January 4, 1986         *)
  11.           (*                                         *)
  12.           (*******************************************)
  13.  
  14. The following changes to Turbo DataBase ToolBox code will permit your database
  15. programs to access more than 65,536 records (DOS only).  With a three-byte
  16. integer replacing the standard integer as record numbers and page numbers, the
  17. maximum number of records in the BIGTREE system becomes 16,777,214.  Note
  18. that the minimum record size increases to 16 as a result.  I have added
  19. code to default to the correct file size if the record length<16.
  20.  
  21. NOTE:  With the increased capacity of BIGTREE, it is possible to specify
  22. a tree structure that is inadequate to handle the maximum number of
  23. records.  The maximum tree capacity is a function of PageSize and MaxHeight
  24. (and, of course, Order).  For instance, with MaxHeight=5 you should set
  25. PageSize to at least 52 to accomodate 16M records.
  26.  
  27. I have not tested these changes thoroughly.  Use at your own risk.
  28. If you use BIGTREE, successfully or otherwise, I'd appreciate it if you'd
  29. let me know how it works for you.  Leave a message in the forum for
  30. Bruce Butters [76317,2433].
  31.  
  32. Good Luck!
  33.  
  34.  
  35. CHANGES TO ACCESS3.BOX:
  36. ----------------------
  37.  
  38.   1.  add a constant declaration:  const  MinDataRecLen=16;
  39.  
  40. Changes to type declarations:
  41.  
  42.   2.  The first type declaration should be LongInt  =  string[3];
  43.   3.  Change the DataFile type to
  44.  
  45.     DataFile  =  record
  46.                  case Integer of
  47.                    0 : (F          : file;
  48.                         FirstFree,
  49.                         NumberFree,
  50.                         Int1,
  51.                         Int2,
  52.                         NumRec     : LongInt);
  53.                    1 : (Fil2       : array[1..12] of Byte;
  54.                         TaName     : array[1..64] of Char);
  55.                end;
  56.   4.  With TaItem change type of DataRef and PageRef to LongInt.
  57.   5.  With TaPage change type of BckwPageRef to LongInt.
  58.   6.  With TaSearchStep change type of PageRef to LongInt.
  59.   7.  With IndexFile change type of RR (only) to LongInt.
  60.   8.  With TaStackRec change type of PageRef to LongInt.
  61.   9.  With TaRecordBuffer change type of I to LongInt.
  62.  
  63. Changes to functions & procedures:
  64.  
  65.  10. add the following functions as the first functions in the code:
  66.  
  67.      (If you can come up with more elegant code than these
  68.       two kludges, please feel free to share them)
  69.  
  70.  
  71.          FUNCTION Long(R : real)  : LongInt;
  72.          var
  73.            n  :  real;
  74.            i  :  integer;
  75.          begin
  76.          R := abs(R);
  77.          i := trunc(R/65536.0);
  78.          Long[1] := chr(i);
  79.          n := (R-(i*65536.0));
  80.          if n<32768.0 then i := trunc(n)
  81.            else if n>32768.0 then i := trunc(n-65536.0)
  82.              else i := $8000;  {Turbo won't accept -32768}
  83.          Long[3] := chr(lo(i));
  84.          Long[2] := chr(hi(i));
  85.          Long[0] := chr(3);
  86.          end; {Long}
  87.  
  88.          FUNCTION LongVal(I  :  LongInt) : real;
  89.          var
  90.            R  :  real;
  91.            n  :  integer;
  92.          begin
  93.          R := ord(I[1])*65536.0;
  94.          n := ord(I[2])*256+ord(I[3]);
  95.          if n<0 then R := R+65536.0+n else R := R+n;
  96.          LongVal := R;
  97.          end; {LongVal}
  98.  
  99.  11.  In TaIOCheck change parameter type R to real and change
  100.       writeln(' Record ',R) to writeln(' Record ',R:0:0);
  101.  
  102.  12.  In GetRec change the type of parameter R to real.  Change
  103.       Seek(DatF.F,R);  to  LongSeek(DatF.F,R);
  104.  
  105.  13.  In PutRec change the type of parameter R to real.  Change
  106.       Seek(DatF.F,R) to LongSeek(DatF.F,R);
  107.  
  108.  14.  In MakeFile add a var R : Integer; to the procedure.
  109.       After the first call to TaIOCheck add
  110.  
  111.         if RecLen<MinDataRecLen then R := MinDataRecLen else R := RecLen;
  112.  
  113.       then change Rewrite(DatF.F,RecLen) to Rewrite(DatF.F,R);
  114.       Change the record zero initialization to
  115.  
  116.         else
  117.         begin
  118.           TaIOCheck(DatF,0);
  119.           DatF.FirstFree := Long(0);
  120.           DatF.NumberFree := Long(0);
  121.           DatF.Int1 := Long(0);
  122.           DatF.Int2 := Long(0);
  123.           Move(DatF.FirstFree,TaRecBuf,16);
  124.           PutRec(DatF,0,TaRecBuf);
  125.           DatF.NumRec := Long(1.0);
  126.           OK := true;
  127.         end;
  128.  
  129.  15.  In OpenFile add a var R : Integer; to the procedure.
  130.       After the first call to TaIOCheck add
  131.  
  132.         if RecLen<MinDataRecLen then R := MinDataRecLen else R := RecLen;
  133.  
  134.       Then:  Reset(DatF.F,R);
  135.  
  136.       Change the number of bytes in the Move procedure from 8 to 16.
  137.  
  138.       Then:   DatF.NumRec := Long(LongFileSize(DatF.F));
  139.  
  140.  16.  In CloseFile change the number of bytes in the Move procedure from
  141.       8 to 16.
  142.  
  143.  17.  In NewRec change the parameter R to type real.
  144.  
  145.       Then:
  146.  
  147.         if LongVal(DatF.FirstFree) < 1.0 then
  148.           begin
  149.           R := LongVal(DatF.NumRec);
  150.           DatF.NumRec := Long(R + 1.0);
  151.           end
  152.         else
  153.           begin
  154.           R := LongVal(DatF.FirstFree);
  155.           GetRec(DatF,R,TaRecBuf);
  156.           DatF.FirstFree := TaRecBuf.I;
  157.           DatF.NumberFree := Long(LongVal(DatF.NumberFree) - 1.0);
  158.           end;
  159.  
  160.  18.  In AddRec change parameter R to type real.
  161.  
  162.  19.  In DeleteRec change parameter R to real.  After the PutRec
  163.       statement, then:
  164.  
  165.         DatF.FirstFree := Long(R);
  166.         DatF.NumberFree := Long(LongVal(DatF.NumberFree) + 1.0);
  167.  
  168.  20.  Change the result type of FileLen to real.  The function
  169.       statement then is:  FileLen := LongVal(DatF.NumRec);
  170.  
  171.  21.  Change the result type of UsedRecs to real.  The function
  172.       statement then is:
  173.  
  174.         UsedRecs := LongVal(DatF.NumRec) - LongVal(DatF.NumberFree) - 1.0;
  175.  
  176.  22.  Change the Move procedure in TaPack to:
  177.  
  178.         Move(Page.ItemArray[I],P[(I - 1) * (KeyL + 9) + 5],KeyL + 9);
  179.  
  180.  23.  Change the Move procedure in TaUnpack to:
  181.  
  182.         Move(P[(I - 1) * (KeyL + 9) + 5],Page.ItemArray[I],KeyL + 9);
  183.  
  184.  24.  Change the first statement in MakeIndex to:
  185.  
  186.         K := (KeyLen + 9)*PageSize + 5;
  187.  
  188.         then change IdxF.RR := 0;  to  IdxF.RR := Long(0);
  189.  
  190.  25.  Change the first statement of OpenIndex to:
  191.  
  192.         K := (KeyLen + 9) * PageSize + 5;
  193.  
  194.  26.  In CloseIndex, change the PutRec statement to:
  195.  
  196.           PutRec(IdxF.DataF,LongVal(PageRef),Page);
  197.  
  198.  27.  Change the parameter R in TaGetPage to type real.
  199.       The assignment to Boolean Found should read:
  200.  
  201.         Found := (IndexFPtr = Addr(IdxF)) and (LongVal(PageRef) = R);
  202.  
  203.       Change the call to PutRec to:
  204.  
  205.         PutRec(IndexFPtr^.DataF,LongVal(PageRef),Page);
  206.  
  207.       Then the assignment to PageRef to:    PageRef := Long(R);
  208.  
  209.  28.  Change the parameter R in TaNewPage to type real.
  210.       Change the call to PutRec to:
  211.  
  212.         PutRec(IndexFPtr^.DataF,LongVal(PageRef),Page);
  213.  
  214.       Then the assignment to PageRef should be:  PageRef := Long(R);
  215.  
  216.  29.  In TaReturnPage change the call to DeleteRec to:
  217.  
  218.         DeleteRec(IndexFPtr^.DataF,LongVal(PageRef));
  219.  
  220.  30.  In TaCompKeys change the parameter type of DR1 and DR2 to real.
  221.       Then, change
  222.  
  223.             if Dup then
  224.               TaCompKeys := DR1 - DR2
  225.             else TaCompKeys := 0
  226.       to:
  227.             if Dup then
  228.               begin
  229.               if DR1>DR2 then TaCompKeys:=1 else
  230.                 if DR1<DR2 then TaCompKeys:=-1
  231.               end
  232.             else TaCompKeys := 0;
  233.  
  234.  
  235. CHANGES TO GETKEY.BOX:
  236. ---------------------
  237.  
  238.   1.  In NextKey, change the parameter ProcDataRef type to real.  Also,
  239.       change the variable R to type real.
  240.  
  241.       Change line  5  ('begin' = line 1) to:       R := LongVal(RR)
  242.  
  243.       Change lines 9 and 10 to:
  244.  
  245.         TaGetPage(IdxF,LongVal(PageRef),PagPtr);
  246.         R := LongVal(PagPtr^.ItemArray[ItemArrIndex].PageRef);
  247.  
  248.       Change line 17 to:  PageRef := Long(R);
  249.  
  250.       Line 21 to:        R := LongVal(PagPtr^.BckwPageRef);
  251.  
  252.       Line 29 to:        TaGetPage(IdxF,LongVal(Path[PP].PageRef),PagPtr);
  253.  
  254.       Line 38 to:        ProcDatRef := LongVal(DataRef);
  255.  
  256.   2.  In PrevKey, change parameter ProcDataRef to type real.  Also,
  257.       change the variable R to type real.
  258.  
  259.       Change line 5 to:      R := LongVal(RR)
  260.  
  261.       Change line 9 to:      TaGetPage(IdxF,LongVal(PageRef),PagPtr);
  262.  
  263.       Change lines 12 & 13 to:
  264.  
  265.         R := LongVal(PagPtr^.BckwPageRef)
  266.           else R := LongVal(PagPtr^.ItemArray[ItemArrIndex].PageRef);
  267.  
  268.       Line 21 to:   PageRef := Long(R);
  269.  
  270.       Line 25 to:   R := LongVal(ItemArray[ItemsOnPage].PageRef);
  271.  
  272.       Line 32 to:   TaGetPage(IdxF,LongVal(Path[PP].PageRef),PagPtr);
  273.  
  274.       Line 38 to:   ProcDatRef := LongVal(DataRef);
  275.  
  276.   3.  In TaFindKey change parameter ProcDataRef to type real.  Also,
  277.       change variable PrPgRef to type real.
  278.  
  279.       Line 7 to:     PrPgRef := LongVal(RR);
  280.  
  281.       Line 11 to:  Path[PP].PageRef := Long(PrPgRef);
  282.  
  283.       Change lines 19 through 23 to:
  284.  
  285.         C := TaCompKeys(PKey,
  286.                         ItemArray[K].Key,
  287.                         0,
  288.                         LongVal(ItemArray[K].DataRef),
  289.                         AllowDuplKeys        );
  290.  
  291.       Line 31 to:    ProcDatRef := LongVal(ItemArray[K].DataRef);
  292.  
  293.       Lines 36 & 37 to:
  294.  
  295.           PrPgRef := LongVal(BckwPageRef)
  296.         else PrPgRef := LongVal(ItemArray[R].PageRef);
  297.  
  298.   4.  In FindKey, change the parameter ProcDataRef to type real.
  299.  
  300.   5.  In SearchKey, change the parameter ProcDataRef to type real.
  301.  
  302. CHANGES TO ADDKEY.BOX
  303. ---------------------
  304.  
  305.   1.  In AddKey, change the parameter ProcDataRef to type real.
  306.       Change the variables PrPgRef1, PrPgRef2 to type real and
  307.       add a variable Temp : real.
  308.  
  309.   2.  In Search, change the parameter PrPageRef1 to type real.
  310.  
  311.   3.  In Insert, 7 lines from the last 'end' (of Insert) change to:
  312.  
  313.         ProcItem2.PageRef := Long(PrPgRef2);
  314.  
  315.   4.  In the body of Search ('begin' = line 1) change lines
  316.       8 & 9 to:
  317.  
  318.         DataRef := Long(ProcDatRef);
  319.         PageRef := Long(0);
  320.  
  321.       Change lines 21-25 to:
  322.  
  323.         C := TaCompKeys(PKey,
  324.                         ItemArray[K].Key,
  325.                         ProcDatRef,
  326.                         LongVal(ItemArray[K].DataRef),
  327.                         IdxF.AllowDuplKeys   );
  328.  
  329.       Change lines 38-40 to:
  330.  
  331.         if R = 0 then
  332.             Search(LongVal(BckwPageRef))
  333.           else Search(LongVal(ItemArray[R].PageRef));
  334.  
  335.   5.  In the body of AddKey, change line 6 to:  Search(LongVal(RR));
  336.       Starting with line 8, change to:
  337.  
  338.          begin
  339.            PrPgRef1:=LongVal(RR);
  340.            Temp:=PrPgRef;
  341.            TaNewPage(IdxF,Temp,PagePtr1);
  342.            if Temp<>LongVal(RR) then RR:=Long(Temp);
  343.            with PagePtr1^ do
  344.            begin
  345.              ItemsOnPage:=1;
  346.              BckwPageRef:=Long(PrPgRef1);
  347.              {then continue as in original code}
  348.  
  349.  
  350. CHANGES TO DELKEY.BOX
  351. ---------------------
  352.  
  353.   1.  In DeleteKey, change the parameter ProcDataRef to type real.
  354.  
  355.   2.  In DelB, change the parameter PrPgRef to type real.  Change the
  356.       variable XPageRef to type real.
  357.  
  358.   3.  In UnderFlow, change the parameters PrPgRef1 & PrPgRef2 to type
  359.       real.  Change variable LPageRef to type real.
  360.  
  361.       Change line 7 to:  LPageRef := LongVal(PagPtr^.ItemArray[R].PageRef);
  362.  
  363.       Line 17 to:   PagPtr^.ItemArray[R].PageRef := Long(LPageRef);
  364.  
  365.       Lines 41-43 to:
  366.  
  367.         if R = 1 then
  368.           LPageRef := LongVal(PagPtr^.BckwPageRef)
  369.         else LPageRef := LongVal(PagPtr^.ItemArray[R - 1].PageRef);
  370.  
  371.       Line 58 to:  PagPtr^.ItemArray[R].PageRef := Long(PrPgRef2);
  372.  
  373.   4.  In DelA, change the parameter PrPgRef2 to type real.
  374.       Change the variable XPageRef to type real.
  375.  
  376.       Change line 5 to:   XPageRef := LongVal(ItemArray[ItemsOnPage].PageRef);
  377.  
  378.   5.  In the body of DelB, change lines 16-20 ('begin' = line 1) to:
  379.  
  380.         C := TaCompKeys(PKey,
  381.                         ItemArray[K].Key,
  382.                         ProcDatRef,
  383.                         LongVal(ItemArray[K].DataRef),
  384.                         IdxF.AllowDuplKeys   );
  385.  
  386.       Lines 26-28 to:
  387.  
  388.         if R = 0 then
  389.           XPageRef := LongVal(BckwPageRef)
  390.         else XPageRef := LongVal(ItemArray[R].PageRef);
  391.  
  392.       Line 31 to:   ProcDatRef := LongVal(ItemArray[K].DataRef);
  393.  
  394.   6.  In the body of DeleteKey, change line 6 to:
  395.  
  396.         DelB(LongVal(RR));
  397.  
  398.       Change line 9 to:  TaGetPage(IdxF,LongVal(RR),PagPtr);
  399.  
  400.  
  401.  
  402.  
  403.  
  404.                         THAT'S ALL!!!